package accidence;

import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
import java.util.stream.Collectors;

/**
 * HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序
 *
 * @author sdm
 * @version 1.0
 * @date 2023/3/21 8:36
 */
public class HJ101 {


    /**
     * 总结：
     *      数组升序、降序：
     *          1. Arrays.sort(arr);   //默认是升序
     *          2. 实现Comparator，重写compare方法    Arrays.sort(arr， 我的比较器); 我的比较器返回 1，升序，   返回0，相等，   返回-1，降序
     *              Arrays.sort(arr, new Comparator<Integer>(){ @Override
     *                 public int compare(Integer o1, Integer o2) {
     *                     return o2 - o1;  // 降序
     *                     return o1 - o2;  // 升序
     *                 }}
     *          3. 排序算法   ①选择排序  ②冒泡排序 ③快排 ④插入排序       https://www.runoob.com/w3cnote/ten-sorting-algorithm.html
     *          4. 自然排序 Collections.sort(strList, Comparator.naturalOrder());
     *
     */

    @Test
    public void My(){
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int [] arr = new int[a];
        for(int i = 0; i < a; i++){
            arr[i] = in.nextInt();
        }
        int b = in.nextInt();

        if(b == 0){
            Arrays.sort(arr);
        }else if(b == 1){
            // 选择排序 从当前位置开始，和右侧剩余的其他数依次比较，确定最小的数放到当前位置
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = arr.length-1; j > i; j--) {
                    if(arr[j] > arr[i]){
                        int temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
//        //降序
//        if(b == 1){
//            Arrays.sort(Arrays.stream(arr).boxed().toArray(Integer[]::new), new Comparator<Integer>(){
//                @Override
//                public int compare(Integer o1, Integer o2) {
//                    return o2 - o1;
//                }
//            });
//        }else{
//            Arrays.sort(arr);   //默认是升序
//        }

        for (int j : arr) {
            System.out.print(j + " ");
        }

    }





    @Test
    public void HJ1011(){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            Integer[] a = new Integer[N];
            for(int i=0;i<N;i++){
                a[i] = in.nextInt();
            }
            int flag = in.nextInt();
            sortIntegerArray(a,flag);
        }
        in.close();
    }

    public static void sortIntegerArray(Integer[] a,int flag){
        if(flag==0){
            //升序
            Arrays.sort(a);
        }else{
            //降序
            Arrays.sort(a,new MyComparator());
        }
        for(int i=0;i<a.length;i++){
            if(i==a.length-1)
                System.out.print(a[i]);
            else
                System.out.print(a[i]+" ");
        }
        System.out.println();
    }
}

    class MyComparator implements Comparator<Integer>{
        @Override
        public int compare(Integer o1, Integer o2) {
            if(o1.intValue()<o2.intValue())
                return 1;
            else if(o1.intValue()==o2.intValue())
                return 0;
            else
                return -1;
        }
    }


    /**
     *      Java中List, Integer[], int[]的相互转换
     *         int[] data = {4, 5, 3, 6, 2, 5, 1};
     *
     *         int[] 转 List<Integer>
     *              List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
     *              // Arrays.stream(arr) 可以替换成IntStream.of(arr)。
     *              // 1.使用Arrays.stream将int[]转换成IntStream。
     *              // 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
     *              // 3.使用Stream的collect()，将Stream<T>转换成List<T>，因此正是List<Integer>。
     *
     *         int[] 转 Integer[]
     *              Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
     *              // 前两步同上，此时是Stream<Integer>。
     *              // 然后使用Stream的toArray，传入IntFunction<A[]> generator。
     *              // 这样就可以返回Integer数组。
     *              // 不然默认是Object[]。
     *
     *         List<Integer> 转 Integer[]
     *              Integer[] integers2 = list1.toArray(new Integer[0]);
     *              //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
     *              // List<String>转String[]也同理。
     *
     *         List<Integer> 转 int[]
     *              int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
     *              // 想要转换成int[]类型，就得先转成IntStream。
     *              // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
     *              // 而IntStream中默认toArray()转成int[]。
     *
     *         Integer[] 转 int[]
     *              int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
     *              // 思路同上。先将Integer[]转成Stream<Integer>，再转成IntStream。
     *
     *         Integer[] 转 List<Integer>
     *              List<Integer> list2 = Arrays.asList(integers1);
     *              // 最简单的方式。String[]转List<String>也同理。
     *
     *     // 同理  String[] List[] 互转
     *     String[] strings1 = {"a", "b", "c"};
     *         String[] 转 List<String>
     *              List<String> list3 = Arrays.asList(strings1);
     *
     *         List<String> 转 String[]
     *         String[] strings2 = list3.toArray(new String[0]);
     *
     */



